home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / m72.c < prev    next >
C/C++ Source or Header  |  2000-05-04  |  18KB  |  700 lines
  1. #include "driver.h"
  2. #include "sndhrdw/m72.h"
  3.  
  4.  
  5.  
  6. unsigned char *m72_videoram1,*m72_videoram2,*majtitle_rowscrollram;
  7. static unsigned char *m72_spriteram;
  8. static int rastersplit;
  9. static int splitline;
  10. static struct tilemap *fg_tilemap,*bg_tilemap;
  11. static int xadjust;
  12. static int scrollx1[256],scrolly1[256],scrollx2[256],scrolly2[256];
  13. extern unsigned char *spriteram,*spriteram_2;
  14. extern size_t spriteram_size;
  15.  
  16. static int irq1,irq2;
  17.  
  18. void m72_init_machine(void)
  19. {
  20.     irq1 = 0x20;
  21.     irq2 = 0x22;
  22.  
  23.     m72_init_sound();
  24. }
  25.  
  26. void xmultipl_init_machine(void)
  27. {
  28.     irq1 = 0x08;
  29.     irq2 = 0x0a;
  30.     m72_init_sound();
  31. }
  32.  
  33. void poundfor_init_machine(void)
  34. {
  35.     irq1 = 0x18;
  36.     irq2 = 0x1a;
  37.     m72_init_sound();
  38. }
  39.  
  40. int m72_interrupt(void)
  41. {
  42.     int line = 255 - cpu_getiloops();
  43.  
  44.     if (line == 255)    /* vblank */
  45.     {
  46.         rastersplit = 0;
  47.         interrupt_vector_w(0,irq1);
  48.         return interrupt();
  49.     }
  50.     else
  51.     {
  52.         if (line != splitline - 128)
  53.             return ignore_interrupt();
  54.  
  55.         rastersplit = line + 1;
  56.  
  57.         /* this is used to do a raster effect and show the score display at
  58.            the bottom of the screen or other things. The line where the
  59.            interrupt happens is programmable (and the interrupt can be triggered
  60.            multiple times, by changing the interrupt line register in the
  61.            interrupt handler).
  62.          */
  63.         interrupt_vector_w(0,irq2);
  64.         return interrupt();
  65.     }
  66. }
  67.  
  68.  
  69.  
  70. /***************************************************************************
  71.  
  72.   Callbacks for the TileMap code
  73.  
  74. ***************************************************************************/
  75.  
  76. static void m72_get_bg_tile_info(int tile_index)
  77. {
  78.     unsigned char attr = m72_videoram2[4*tile_index+1];
  79.     SET_TILE_INFO(2,m72_videoram2[4*tile_index] + ((attr & 0x3f) << 8),m72_videoram2[4*tile_index+2] & 0x0f)
  80.     tile_info.flags = TILE_FLIPYX((attr & 0xc0) >> 6);
  81. }
  82.  
  83. static void m72_get_fg_tile_info(int tile_index)
  84. {
  85.     unsigned char attr = m72_videoram1[4*tile_index+1];
  86.     SET_TILE_INFO(1,m72_videoram1[4*tile_index] + ((attr & 0x3f) << 8),m72_videoram1[4*tile_index+2] & 0x0f)
  87. /* bchopper: (videoram[4*tile_index+2] & 0x10) is used, priority? */
  88.     tile_info.flags = TILE_FLIPYX((attr & 0xc0) >> 6);
  89.  
  90.     tile_info.priority = (m72_videoram1[4*tile_index+2] & 0x80) >> 7;
  91. }
  92.  
  93. static void dbreed_get_bg_tile_info(int tile_index)
  94. {
  95.     unsigned char attr = m72_videoram2[4*tile_index+1];
  96.     SET_TILE_INFO(2,m72_videoram2[4*tile_index] + ((attr & 0x3f) << 8),m72_videoram2[4*tile_index+2] & 0x0f)
  97.     tile_info.flags = TILE_FLIPYX((attr & 0xc0) >> 6);
  98.  
  99.     /* this seems to apply only to Dragon Breed, it breaks R-Type and Gallop */
  100.     tile_info.priority = (m72_videoram2[4*tile_index+2] & 0x80) >> 7;
  101. }
  102.  
  103. static void rtype2_get_bg_tile_info(int tile_index)
  104. {
  105.     unsigned char attr = m72_videoram2[4*tile_index+2];
  106.     SET_TILE_INFO(1,m72_videoram2[4*tile_index] + (m72_videoram2[4*tile_index+1] << 8),attr & 0x0f)
  107.     tile_info.flags = TILE_FLIPYX((attr & 0x60) >> 5);
  108. }
  109.  
  110. static void rtype2_get_fg_tile_info(int tile_index)
  111. {
  112.     unsigned char attr = m72_videoram1[4*tile_index+2];
  113.     SET_TILE_INFO(1,m72_videoram1[4*tile_index] + (m72_videoram1[4*tile_index+1] << 8),attr & 0x0f)
  114.     tile_info.flags = TILE_FLIPYX((attr & 0x60) >> 5);
  115.  
  116.     tile_info.priority = m72_videoram1[4*tile_index+3] & 0x01;
  117.  
  118. /* TODO: this is used on the continue screen by rtype2. Maybe it selects split tilemap */
  119. /* like in M92 (top 8 pens appear over sprites), however if it is only used in that */
  120. /* place there's no need to support it, it's just a black screen... */
  121.     tile_info.priority |= (m72_videoram1[4*tile_index+2] & 0x80) >> 7;
  122.  
  123. /* (videoram[tile_index+2] & 0x10) is used by majtitle on the green, but it's not clear for what */
  124. /* (videoram[tile_index+3] & 0xfe) are used as well */
  125. }
  126.  
  127. static void majtitle_get_bg_tile_info(int tile_index)
  128. {
  129.     unsigned char attr = m72_videoram2[4*tile_index+2];
  130.     SET_TILE_INFO(1,m72_videoram2[4*tile_index] + (m72_videoram2[4*tile_index+1] << 8),attr & 0x0f)
  131.     tile_info.flags = TILE_FLIPYX((attr & 0x60) >> 5);
  132. /* (videoram[4*tile_index+2] & 0x10) is used, but it's not clear for what (priority?) */
  133. }
  134.  
  135. INLINE void hharry_get_tile_info(int gfxnum,unsigned char *videoram,int tile_index)
  136. {
  137.     unsigned char attr = videoram[4*tile_index+1];
  138.     SET_TILE_INFO(gfxnum,videoram[4*tile_index] + ((attr & 0x3f) << 8),videoram[4*tile_index+2] & 0x0f)
  139.     tile_info.flags = TILE_FLIPYX((attr & 0xc0) >> 6);
  140. /* (videoram[4*tile_index+2] & 0x10) is used, but it's not clear for what (priority?) */
  141. }
  142.  
  143. static void hharry_get_bg_tile_info(int tile_index)
  144. {
  145.     hharry_get_tile_info(1,m72_videoram2,tile_index);
  146. }
  147.  
  148. static void hharry_get_fg_tile_info(int tile_index)
  149. {
  150.     hharry_get_tile_info(1,m72_videoram1,tile_index);
  151. }
  152.  
  153.  
  154. /***************************************************************************
  155.  
  156.   Start the video hardware emulation.
  157.  
  158. ***************************************************************************/
  159.  
  160. int m72_vh_start(void)
  161. {
  162.     int i;
  163.  
  164.  
  165.     bg_tilemap = tilemap_create(m72_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,64,64);
  166.     fg_tilemap = tilemap_create(m72_get_fg_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,64);
  167.  
  168.     m72_spriteram = malloc(spriteram_size);
  169.  
  170.     if (!fg_tilemap || !bg_tilemap || !m72_spriteram)
  171.         return 1;
  172.  
  173.     fg_tilemap->transparent_pen = 0;
  174.  
  175.     memset(m72_spriteram,0,spriteram_size);
  176.  
  177.     xadjust = 0;
  178.  
  179.     /* improves bad gfx in nspirit (but this is not a complete fix, maybe there's a */
  180.     /* layer enable register */
  181.     for (i = 0;i < Machine->drv->total_colors;i++)
  182.         palette_change_color(i,0,0,0);
  183.  
  184.     return 0;
  185. }
  186.  
  187. int dbreed_vh_start(void)
  188. {
  189.     bg_tilemap = tilemap_create(dbreed_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,64,64);
  190.     fg_tilemap = tilemap_create(m72_get_fg_tile_info,   tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,64);
  191.  
  192.     m72_spriteram = malloc(spriteram_size);
  193.  
  194.     if (!fg_tilemap || !bg_tilemap || !m72_spriteram)
  195.         return 1;
  196.  
  197.     fg_tilemap->transparent_pen = 0;
  198.  
  199.     memset(m72_spriteram,0,spriteram_size);
  200.  
  201.     xadjust = 0;
  202.  
  203.     return 0;
  204. }
  205.  
  206. int rtype2_vh_start(void)
  207. {
  208.     bg_tilemap = tilemap_create(rtype2_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,64,64);
  209.     fg_tilemap = tilemap_create(rtype2_get_fg_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,64);
  210.  
  211.     m72_spriteram = malloc(spriteram_size);
  212.  
  213.     if (!fg_tilemap || !bg_tilemap || !m72_spriteram)
  214.         return 1;
  215.  
  216.     fg_tilemap->transparent_pen = 0;
  217.  
  218.     memset(m72_spriteram,0,spriteram_size);
  219.  
  220.     xadjust = -4;
  221.  
  222.     return 0;
  223. }
  224.  
  225. /* Major Title has a larger background RAM, and rowscroll */
  226. int majtitle_vh_start(void)
  227. {
  228. // tilemap can be 256x64, but seems to be used at 128x64 (scroll wraparound) */
  229. //    bg_tilemap = tilemap_create(majtitle_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,256,64);
  230.     bg_tilemap = tilemap_create(majtitle_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,128,64);
  231.     fg_tilemap = tilemap_create(rtype2_get_fg_tile_info,  tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,64);
  232.  
  233.     m72_spriteram = malloc(spriteram_size);
  234.  
  235.     if (!fg_tilemap || !bg_tilemap || !m72_spriteram)
  236.         return 1;
  237.  
  238.     fg_tilemap->transparent_pen = 0;
  239.  
  240.     memset(m72_spriteram,0,spriteram_size);
  241.  
  242.     xadjust = -4;
  243.  
  244.     return 0;
  245. }
  246.  
  247. int hharry_vh_start(void)
  248. {
  249.     bg_tilemap = tilemap_create(hharry_get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,64,64);
  250.     fg_tilemap = tilemap_create(hharry_get_fg_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,64);
  251.  
  252.     m72_spriteram = malloc(spriteram_size);
  253.  
  254.     if (!fg_tilemap || !bg_tilemap || !m72_spriteram)
  255.         return 1;
  256.  
  257.     fg_tilemap->transparent_pen = 0;
  258.  
  259.     memset(m72_spriteram,0,spriteram_size);
  260.  
  261.     xadjust = -4;
  262.  
  263.     return 0;
  264. }
  265.  
  266. void m72_vh_stop(void)
  267. {
  268.     free(m72_spriteram);
  269.     m72_spriteram = 0;
  270. }
  271.  
  272.  
  273.  
  274. /***************************************************************************
  275.  
  276.   Memory handlers
  277.  
  278. ***************************************************************************/
  279.  
  280. READ_HANDLER( m72_palette1_r )
  281. {
  282.     return paletteram[offset];
  283. }
  284.  
  285. READ_HANDLER( m72_palette2_r )
  286. {
  287.     return paletteram_2[offset];
  288. }
  289.  
  290. INLINE void changecolor(int color,int r,int g,int b)
  291. {
  292.     r = (r << 3) | (r >> 2);
  293.     g = (g << 3) | (g >> 2);
  294.     b = (b << 3) | (b >> 2);
  295.  
  296.     palette_change_color(color,r,g,b);
  297. }
  298.  
  299. WRITE_HANDLER( m72_palette1_w )
  300. {
  301.     paletteram[offset] = data;
  302.     if (offset & 1) return;
  303.     offset &= 0x3ff;
  304.     changecolor(offset / 2,
  305.             paletteram[offset + 0x000],
  306.             paletteram[offset + 0x400],
  307.             paletteram[offset + 0x800]);
  308. }
  309.  
  310. WRITE_HANDLER( m72_palette2_w )
  311. {
  312.     paletteram_2[offset] = data;
  313.     if (offset & 1) return;
  314.     offset &= 0x3ff;
  315.     changecolor(offset / 2 + 512,
  316.             paletteram_2[offset + 0x000],
  317.             paletteram_2[offset + 0x400],
  318.             paletteram_2[offset + 0x800]);
  319. }
  320.  
  321. READ_HANDLER( m72_videoram1_r )
  322. {
  323.     return m72_videoram1[offset];
  324. }
  325.  
  326. READ_HANDLER( m72_videoram2_r )
  327. {
  328.     return m72_videoram2[offset];
  329. }
  330.  
  331. WRITE_HANDLER( m72_videoram1_w )
  332. {
  333.     if (m72_videoram1[offset] != data)
  334.     {
  335.         m72_videoram1[offset] = data;
  336.         tilemap_mark_tile_dirty(fg_tilemap,offset/4);
  337.     }
  338. }
  339.  
  340. WRITE_HANDLER( m72_videoram2_w )
  341. {
  342.     if (m72_videoram2[offset] != data)
  343.     {
  344.         m72_videoram2[offset] = data;
  345.         tilemap_mark_tile_dirty(bg_tilemap,offset/4);
  346.     }
  347. }
  348.  
  349. WRITE_HANDLER( majtitle_videoram2_w )
  350. {
  351.     if (m72_videoram2[offset] != data)
  352.     {
  353.         m72_videoram2[offset] = data;
  354. //        tilemap_mark_tile_dirty(bg_tilemap,offset/4);
  355. // tilemap can be 256x64, but seems to be used at 128x64 (scroll wraparound) */
  356. if ((offset/4)%256 < 128)
  357.         tilemap_mark_tile_dirty(bg_tilemap,offset/4);
  358.     }
  359. }
  360.  
  361. WRITE_HANDLER( m72_irq_line_w )
  362. {
  363.     offset *= 8;
  364.     splitline = (splitline & (0xff00 >> offset)) | (data << offset);
  365. }
  366.  
  367. WRITE_HANDLER( m72_scrollx1_w )
  368. {
  369.     int i;
  370.  
  371.     offset *= 8;
  372.     scrollx1[rastersplit] = (scrollx1[rastersplit] & (0xff00 >> offset)) | (data << offset);
  373.  
  374.     for (i = rastersplit+1;i < 256;i++)
  375.         scrollx1[i] = scrollx1[rastersplit];
  376. }
  377.  
  378. WRITE_HANDLER( m72_scrollx2_w )
  379. {
  380.     int i;
  381.  
  382.     offset *= 8;
  383.     scrollx2[rastersplit] = (scrollx2[rastersplit] & (0xff00 >> offset)) | (data << offset);
  384.  
  385.     for (i = rastersplit+1;i < 256;i++)
  386.         scrollx2[i] = scrollx2[rastersplit];
  387. }
  388.  
  389. WRITE_HANDLER( m72_scrolly1_w )
  390. {
  391.     int i;
  392.  
  393.     offset *= 8;
  394.     scrolly1[rastersplit] = (scrolly1[rastersplit] & (0xff00 >> offset)) | (data << offset);
  395.  
  396.     for (i = rastersplit+1;i < 256;i++)
  397.         scrolly1[i] = scrolly1[rastersplit];
  398. }
  399.  
  400. WRITE_HANDLER( m72_scrolly2_w )
  401. {
  402.     int i;
  403.  
  404.     offset *= 8;
  405.     scrolly2[rastersplit] = (scrolly2[rastersplit] & (0xff00 >> offset)) | (data << offset);
  406.  
  407.     for (i = rastersplit+1;i < 256;i++)
  408.         scrolly2[i] = scrolly2[rastersplit];
  409. }
  410.  
  411. WRITE_HANDLER( m72_spritectrl_w )
  412. {
  413. //logerror("%04x: write %02x to sprite ctrl+%d\n",cpu_get_pc(),data,offset);
  414.     /* TODO: this is ok for R-Type, but might be wrong for others */
  415.     if (offset == 1)
  416.     {
  417.         memcpy(m72_spriteram,spriteram,spriteram_size);
  418.         if (data & 0x40) memset(spriteram,0,spriteram_size);
  419.         /* bit 7 is used by bchopper, nspirit, imgfight, loht, gallop - meaning unknown */
  420.         /* rtype2 uses bits 4,5,6 and 7 - of course it could be a different chip */
  421.     }
  422. }
  423.  
  424. WRITE_HANDLER( hharry_spritectrl_w )
  425. {
  426. //logerror("%04x: write %02x to sprite ctrl+%d\n",cpu_get_pc(),data,offset);
  427.     if (offset == 0)
  428.     {
  429.         memcpy(m72_spriteram,spriteram,spriteram_size);
  430.         memset(spriteram,0,spriteram_size);
  431.     }
  432. }
  433.  
  434. WRITE_HANDLER( hharryu_spritectrl_w )
  435. {
  436. //logerror("%04x: write %02x to sprite ctrl+%d\n",cpu_get_pc(),data,offset);
  437.     if (offset == 1)
  438.     {
  439.         memcpy(m72_spriteram,spriteram,spriteram_size);
  440.         if (data & 0x80) memset(spriteram,0,spriteram_size);
  441.         /* hharryu uses bits 2,3,4,5,6 and 7 - of course it could be a different chip */
  442.         /* majtitle uses bits 2,3,5,6 and 7 - of course it could be a different chip */
  443.     }
  444. }
  445.  
  446.  
  447.  
  448. /***************************************************************************
  449.  
  450.   Display refresh
  451.  
  452. ***************************************************************************/
  453.  
  454. static void draw_sprites(struct osd_bitmap *bitmap)
  455. {
  456.     int offs;
  457.  
  458.     for (offs = 0;offs < spriteram_size;offs += 8)
  459.     {
  460.         int code,color,sx,sy,flipx,flipy,w,h,x,y;
  461.  
  462.  
  463.         code = m72_spriteram[offs+2] | (m72_spriteram[offs+3] << 8);
  464.         color = m72_spriteram[offs+4] & 0x0f;
  465.         sx = -256+(m72_spriteram[offs+6] | ((m72_spriteram[offs+7] & 0x03) << 8));
  466.         sy = 512-(m72_spriteram[offs+0] | ((m72_spriteram[offs+1] & 0x01) << 8));
  467.         flipx = m72_spriteram[offs+5] & 0x08;
  468.         flipy = m72_spriteram[offs+5] & 0x04;
  469.  
  470.         w = 1 << ((m72_spriteram[offs+5] & 0xc0) >> 6);
  471.         h = 1 << ((m72_spriteram[offs+5] & 0x30) >> 4);
  472.         sy -= 16 * h;
  473.  
  474.         for (x = 0;x < w;x++)
  475.         {
  476.             for (y = 0;y < h;y++)
  477.             {
  478.                 int c = code;
  479.  
  480.                 if (flipx) c += 8*(w-1-x);
  481.                 else c += 8*x;
  482.                 if (flipy) c += h-1-y;
  483.                 else c += y;
  484.  
  485.                 drawgfx(bitmap,Machine->gfx[0],
  486.                         c,
  487.                         color,
  488.                         flipx,flipy,
  489.                         sx + 16*x,sy + 16*y,
  490.                         &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  491.             }
  492.         }
  493.     }
  494. }
  495.  
  496. static void majtitle_draw_sprites(struct osd_bitmap *bitmap)
  497. {
  498.     int offs;
  499.  
  500.     for (offs = 0;offs < spriteram_size;offs += 8)
  501.     {
  502.         int code,color,sx,sy,flipx,flipy,w,h,x,y;
  503.  
  504.  
  505.         code = spriteram_2[offs+2] | (spriteram_2[offs+3] << 8);
  506.         color = spriteram_2[offs+4] & 0x0f;
  507.         sx = -256+(spriteram_2[offs+6] | ((spriteram_2[offs+7] & 0x03) << 8));
  508.         sy = 512-(spriteram_2[offs+0] | ((spriteram_2[offs+1] & 0x01) << 8));
  509.         flipx = spriteram_2[offs+5] & 0x08;
  510.         flipy = spriteram_2[offs+5] & 0x04;
  511.  
  512.         w = 1;// << ((spriteram_2[offs+5] & 0xc0) >> 6);
  513.         h = 1 << ((spriteram_2[offs+5] & 0x30) >> 4);
  514.         sy -= 16 * h;
  515.  
  516.         for (x = 0;x < w;x++)
  517.         {
  518.             for (y = 0;y < h;y++)
  519.             {
  520.                 int c = code;
  521.  
  522.                 if (flipx) c += 8*(w-1-x);
  523.                 else c += 8*x;
  524.                 if (flipy) c += h-1-y;
  525.                 else c += y;
  526.  
  527.                 drawgfx(bitmap,Machine->gfx[2],
  528.                         c,
  529.                         color,
  530.                         flipx,flipy,
  531.                         sx + 16*x,sy + 16*y,
  532.                         &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  533.             }
  534.         }
  535.     }
  536. }
  537.  
  538. static void mark_sprite_colors(unsigned char *ram)
  539. {
  540.     int offs,color,i;
  541.     int colmask[32];
  542.     int pal_base;
  543.  
  544.  
  545.     pal_base = Machine->drv->gfxdecodeinfo[0].color_codes_start;
  546.  
  547.     for (color = 0;color < 32;color++) colmask[color] = 0;
  548.  
  549.     for (offs = 0;offs < spriteram_size;offs += 8)
  550.     {
  551.         color = ram[offs+4] & 0x0f;
  552.         colmask[color] |= 0xffff;
  553.     }
  554.  
  555.     for (color = 0;color < 32;color++)
  556.     {
  557.         for (i = 1;i < 16;i++)
  558.         {
  559.             if (colmask[color] & (1 << i))
  560.                 palette_used_colors[pal_base + 16 * color + i] |= PALETTE_COLOR_VISIBLE;
  561.         }
  562.     }
  563. }
  564.  
  565. static void draw_layer(struct osd_bitmap *bitmap,
  566.         struct tilemap *tilemap,int *scrollx,int *scrolly,int priority)
  567. {
  568.     int start,i;
  569.     /* use clip regions to split the screen */
  570.     struct rectangle clip;
  571.  
  572.     clip.min_x = Machine->drv->visible_area.min_x;
  573.     clip.max_x = Machine->drv->visible_area.max_x;
  574.     start = Machine->drv->visible_area.min_y - 128;
  575.     do
  576.     {
  577.         i = start;
  578.         while (scrollx[i+1] == scrollx[start] && scrolly[i+1] == scrolly[start]
  579.                 && i < Machine->drv->visible_area.max_y - 128)
  580.             i++;
  581.  
  582.         clip.min_y = start + 128;
  583.         clip.max_y = i + 128;
  584.         tilemap_set_clip(tilemap,&clip);
  585.         tilemap_set_scrollx(tilemap,0,scrollx[start] + xadjust);
  586.         tilemap_set_scrolly(tilemap,0,scrolly[start]);
  587.         tilemap_draw(bitmap,tilemap,priority);
  588.  
  589.         start = i+1;
  590.     } while (start < Machine->drv->visible_area.max_y - 128);
  591. }
  592.  
  593. static void draw_bg(struct osd_bitmap *bitmap,int priority)
  594. {
  595.     draw_layer(bitmap,bg_tilemap,scrollx2,scrolly2,priority);
  596. }
  597.  
  598. static void draw_fg(struct osd_bitmap *bitmap,int priority)
  599. {
  600.     draw_layer(bitmap,fg_tilemap,scrollx1,scrolly1,priority);
  601. }
  602.  
  603.  
  604. void m72_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  605. {
  606.     tilemap_set_clip(fg_tilemap,0);
  607.     tilemap_set_clip(bg_tilemap,0);
  608.  
  609.     tilemap_update(bg_tilemap);
  610.     tilemap_update(fg_tilemap);
  611.  
  612.     palette_init_used_colors();
  613.     mark_sprite_colors(m72_spriteram);
  614.     if (palette_recalc())
  615.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  616.  
  617.     tilemap_render(ALL_TILEMAPS);
  618.  
  619.     draw_bg(bitmap,0);
  620.     draw_fg(bitmap,0);
  621.     draw_sprites(bitmap);
  622.     draw_fg(bitmap,1);
  623. }
  624.  
  625. void dbreed_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  626. {
  627.     tilemap_set_clip(fg_tilemap,0);
  628.     tilemap_set_clip(bg_tilemap,0);
  629.  
  630.     tilemap_update(bg_tilemap);
  631.     tilemap_update(fg_tilemap);
  632.  
  633.     palette_init_used_colors();
  634.     mark_sprite_colors(m72_spriteram);
  635.     if (palette_recalc())
  636.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  637.  
  638.     tilemap_render(ALL_TILEMAPS);
  639.  
  640.     draw_bg(bitmap,0);
  641.     draw_fg(bitmap,0);
  642.     draw_sprites(bitmap);
  643.     draw_bg(bitmap,1);
  644.     draw_fg(bitmap,1);
  645. }
  646.  
  647. void majtitle_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  648. {
  649.     int i;
  650.  
  651.  
  652.     tilemap_set_clip(fg_tilemap,0);
  653.  
  654.     /* TODO: find how rowscroll is disabled */
  655.     if (1)
  656.     {
  657.         tilemap_set_scroll_rows(bg_tilemap,512);
  658.         for (i = 0;i < 512;i++)
  659.             tilemap_set_scrollx(bg_tilemap,(i+scrolly2[0])&0x1ff,
  660.                     256 + majtitle_rowscrollram[2*i] + (majtitle_rowscrollram[2*i+1] << 8) + xadjust);
  661.     }
  662.     else
  663.     {
  664.         tilemap_set_scroll_rows(bg_tilemap,1);
  665.         tilemap_set_scrollx(bg_tilemap,0,256 + scrollx2[0] + xadjust);
  666.     }
  667.     tilemap_set_scrolly(bg_tilemap,0,scrolly2[0]);
  668.     tilemap_update(bg_tilemap);
  669.     tilemap_update(fg_tilemap);
  670.  
  671.     palette_init_used_colors();
  672.     mark_sprite_colors(m72_spriteram);
  673.     mark_sprite_colors(spriteram_2);
  674.     if (palette_recalc())
  675.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  676.  
  677.     tilemap_render(ALL_TILEMAPS);
  678.  
  679.     tilemap_draw(bitmap,bg_tilemap,0);
  680.  
  681.     draw_fg(bitmap,0);
  682.     majtitle_draw_sprites(bitmap);
  683.     draw_sprites(bitmap);
  684.     draw_fg(bitmap,1);
  685. }
  686.  
  687.  
  688. void m72_eof_callback(void)
  689. {
  690.     int i;
  691.  
  692.     for (i = 0;i < 255;i++)
  693.     {
  694.         scrollx1[i] = scrollx1[255];
  695.         scrolly1[i] = scrolly1[255];
  696.         scrollx2[i] = scrollx2[255];
  697.         scrolly2[i] = scrolly2[255];
  698.     }
  699. }
  700.